home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 026-050 / 042 / mg1a / line.c < prev    next >
C/C++ Source or Header  |  1995-03-13  |  16KB  |  609 lines
  1. /*
  2.  *        Text line handling.
  3.  * The functions in this file
  4.  * are a general set of line management
  5.  * utilities. They are the only routines that
  6.  * touch the text. They also touch the buffer
  7.  * and window structures, to make sure that the
  8.  * necessary updating gets done. There are routines
  9.  * in this file that handle the kill buffer too.
  10.  * It isn't here for any good reason.
  11.  *
  12.  * Note that this code only updates the dot and
  13.  * mark values in the window list. Since all the code
  14.  * acts on the current window, the buffer that we
  15.  * are editing must be being displayed, which means
  16.  * that "b_nwnd" is non zero, which means that the
  17.  * dot and mark values in the buffer headers are
  18.  * nonsense.
  19.  */
  20. #include    "def.h"
  21.  
  22. #define    NBLOCK    16            /* Line block chunk size    */
  23.  
  24. #ifndef    KBLOCK
  25. #define    KBLOCK    256            /* Kill buffer block size.    */
  26. #endif
  27.  
  28. static char    *kbufp    = NULL;        /* Kill buffer data.        */
  29. static RSIZE    kused    = 0;        /* # of bytes used in KB.    */
  30. static RSIZE    ksize    = 0;        /* # of bytes allocated in KB.    */
  31. static RSIZE    kstart  = 0;        /* # of first used byte in KB.    */
  32. char    *malloc();
  33. /*
  34.  * This routine allocates a block
  35.  * of memory large enough to hold a LINE
  36.  * containing "used" characters. The block is
  37.  * always rounded up a bit. Return a pointer
  38.  * to the new block, or NULL if there isn't
  39.  * any memory left. Print a message in the
  40.  * message line if no space.
  41.  */
  42. LINE    *
  43. lalloc(used) register RSIZE used; {
  44.     register LINE    *lp;
  45.     register int    size;
  46.  
  47.     /*NOSTRICT*/
  48.     size = (NBLOCK-1+used) & ~(NBLOCK-1);
  49.     if (size == 0)                /* Assume that an empty    */
  50.         size = NBLOCK;            /* line is for type-in.    */
  51.     /*NOSTRICT*/
  52.     if ((lp=(LINE *)malloc(sizeof(LINE)+size)) == NULL) {
  53.         ewprintf("Can't get %d bytes", sizeof(LINE) + size);
  54.         return (NULL);
  55.     }
  56.     lp->l_size = size;
  57.     /*NOSTRICT*/
  58.     lp->l_used = used;
  59.     return (lp);
  60. }
  61.  
  62. /*
  63.  * Delete line "lp". Fix all of the
  64.  * links that might point at it (they are
  65.  * moved to offset 0 of the next line.
  66.  * Unlink the line from whatever buffer it
  67.  * might be in. Release the memory. The
  68.  * buffers are updated too; the magic conditions
  69.  * described in the above comments don't hold
  70.  * here.
  71.  */
  72. lfree(lp) register LINE *lp; {
  73.     register BUFFER    *bp;
  74.     register WINDOW    *wp;
  75.  
  76.     wp = wheadp;
  77.     while (wp != NULL) {
  78.         if (wp->w_linep == lp)
  79.             wp->w_linep = lp->l_fp;
  80.         if (wp->w_dotp  == lp) {
  81.             wp->w_dotp  = lp->l_fp;
  82.             wp->w_doto  = 0;
  83.         }
  84.         if (wp->w_markp == lp) {
  85.             wp->w_markp = lp->l_fp;
  86.             wp->w_marko = 0;
  87.         }
  88.         wp = wp->w_wndp;
  89.     }
  90.     bp = bheadp;
  91.     while (bp != NULL) {
  92.         if (bp->b_nwnd == 0) {
  93.             if (bp->b_dotp  == lp) {
  94.                 bp->b_dotp = lp->l_fp;
  95.                 bp->b_doto = 0;
  96.             }
  97.             if (bp->b_markp == lp) {
  98.                 bp->b_markp = lp->l_fp;
  99.                 bp->b_marko = 0;
  100.             }
  101.         }
  102.         bp = bp->b_bufp;
  103.     }
  104.     lp->l_bp->l_fp = lp->l_fp;
  105.     lp->l_fp->l_bp = lp->l_bp;
  106.     free((char *) lp);
  107. }
  108.  
  109. /*
  110.  * This routine gets called when
  111.  * a character is changed in place in the
  112.  * current buffer. It updates all of the required
  113.  * flags in the buffer and window system. The flag
  114.  * used is passed as an argument; if the buffer is being
  115.  * displayed in more than 1 window we change EDIT to
  116.  * HARD. Set MODE if the mode line needs to be
  117.  * updated (the "*" has to be set).
  118.  */
  119. lchange(flag) register int flag; {
  120.     register WINDOW    *wp;
  121.  
  122.     if (curbp->b_nwnd != 1)            /* Ensure hard.        */
  123.         flag = WFHARD;
  124.     if ((curbp->b_flag&BFCHG) == 0) {    /* First change, so     */
  125.         flag |= WFMODE;            /* update mode lines.    */
  126.         curbp->b_flag |= BFCHG;
  127.     }
  128.     wp = wheadp;
  129.     while (wp != NULL) {
  130.         if (wp->w_bufp == curbp)
  131.             wp->w_flag |= flag;
  132.         wp = wp->w_wndp;
  133.     }
  134. }
  135.  
  136. /*
  137.  * Insert "n" copies of the character "c"
  138.  * at the current location of dot. In the easy case
  139.  * all that happens is the text is stored in the line.
  140.  * In the hard case, the line has to be reallocated.
  141.  * When the window list is updated, take special
  142.  * care; I screwed it up once. You always update dot
  143.  * in the current window. You update mark, and a
  144.  * dot in another window, if it is greater than
  145.  * the place where you did the insert. Return TRUE
  146.  * if all is well, and FALSE on errors.
  147.  */
  148. linsert(n, c) RSIZE n; {
  149.     register char    *cp1;
  150.     register char    *cp2;
  151.     register LINE    *lp1;
  152.     register LINE    *lp2;
  153.     register LINE    *lp3;
  154.     register int    doto;
  155.     register RSIZE    i;
  156.     register WINDOW    *wp;
  157.  
  158.     lchange(WFEDIT);
  159.     lp1 = curwp->w_dotp;            /* Current line        */
  160.     if (lp1 == curbp->b_linep) {        /* At the end: special    */
  161.         if (curwp->w_doto != 0) {
  162.             ewprintf("bug: linsert");
  163.             return (FALSE);
  164.         }
  165.         if ((lp2=lalloc(n)) == NULL)    /* Allocate new line    */
  166.             return (FALSE);
  167.         lp3 = lp1->l_bp;        /* Previous line    */
  168.         lp3->l_fp = lp2;        /* Link in        */
  169.         lp2->l_fp = lp1;
  170.         lp1->l_bp = lp2;
  171.         lp2->l_bp = lp3;
  172.         for (i=0; i<n; ++i)
  173.             lp2->l_text[i] = c;
  174.         wp = wheadp;            /* Update windows    */
  175.         while (wp != NULL) {
  176.             if (wp->w_linep == lp1)
  177.                 wp->w_linep = lp2;
  178.             if (wp->w_dotp == lp1)
  179.                 wp->w_dotp = lp2;
  180.             if (wp->w_markp == lp1)
  181.                 wp->w_markp = lp2;
  182.             wp = wp->w_wndp;
  183.         }
  184.         /*NOSTRICT*/
  185.         curwp->w_doto = n;
  186.         return (TRUE);
  187.     }
  188.     doto = curwp->w_doto;            /* Save for later.    */
  189.     /*NOSTRICT (2) */
  190.     if (lp1->l_used+n > lp1->l_size) {    /* Hard: reallocate    */
  191.         if ((lp2=lalloc((RSIZE) (lp1->l_used+n))) == NULL)
  192.             return (FALSE);
  193.         cp1 = &lp1->l_text[0];
  194.         cp2 = &lp2->l_text[0];
  195.         while (cp1 != &lp1->l_text[doto])
  196.             *cp2++ = *cp1++;
  197.         /*NOSTRICT*/
  198.         cp2 += n;
  199.         while (cp1 != &lp1->l_text[lp1->l_used])
  200.             *cp2++ = *cp1++;
  201.         lp1->l_bp->l_fp = lp2;
  202.         lp2->l_fp = lp1->l_fp;
  203.         lp1->l_fp->l_bp = lp2;
  204.         lp2->l_bp = lp1->l_bp;
  205.         free((char *) lp1);
  206.     } else {                /* Easy: in place    */
  207.         lp2 = lp1;            /* Pretend new line    */
  208.         /*NOSTRICT*/
  209.         lp2->l_used += n;
  210.         cp2 = &lp1->l_text[lp1->l_used];
  211.  
  212.         cp1 = cp2-n;
  213.         while (cp1 != &lp1->l_text[doto])
  214.             *--cp2 = *--cp1;
  215.     }
  216.     for (i=0; i<n; ++i)            /* Add the characters    */
  217.         lp2->l_text[doto+i] = c;
  218.     wp = wheadp;                /* Update windows    */
  219.     while (wp != NULL) {
  220.         if (wp->w_linep == lp1)
  221.             wp->w_linep = lp2;
  222.         if (wp->w_dotp == lp1) {
  223.             wp->w_dotp = lp2;
  224.             if (wp==curwp || wp->w_doto>doto)
  225.                 /*NOSTRICT*/
  226.                 wp->w_doto += n;
  227.         }
  228.         if (wp->w_markp == lp1) {
  229.             wp->w_markp = lp2;
  230.             if (wp->w_marko > doto)
  231.                 /*NOSTRICT*/
  232.                 wp->w_marko += n;
  233.         }
  234.         wp = wp->w_wndp;
  235.     }
  236.     return (TRUE);
  237. }
  238.  
  239. /*
  240.  * Insert a newline into the buffer
  241.  * at the current location of dot in the current
  242.  * window. The funny ass-backwards way it does things
  243.  * is not a botch; it just makes the last line in
  244.  * the file not a special case. Return TRUE if everything
  245.  * works out and FALSE on error (memory allocation
  246.  * failure). The update of dot and mark is a bit
  247.  * easier then in the above case, because the split
  248.  * forces more updating.
  249.  */
  250. lnewline() {
  251.     register char    *cp1;
  252.     register char    *cp2;
  253.     register LINE    *lp1;
  254.     register LINE    *lp2;
  255.     register int    doto;
  256.     register WINDOW    *wp;
  257.  
  258.     lchange(WFHARD);
  259.     lp1  = curwp->w_dotp;            /* Get the address and    */
  260.     doto = curwp->w_doto;            /* offset of "."    */
  261.     if ((lp2=lalloc((RSIZE) doto)) == NULL)    /* New first half line    */
  262.         return (FALSE);
  263.     cp1 = &lp1->l_text[0];            /* Shuffle text around    */
  264.     cp2 = &lp2->l_text[0];
  265.     while (cp1 != &lp1->l_text[doto])
  266.         *cp2++ = *cp1++;
  267.     cp2 = &lp1->l_text[0];
  268.     while (cp1 != &lp1->l_text[lp1->l_used])
  269.         *cp2++ = *cp1++;
  270.     lp1->l_used -= doto;
  271.     lp2->l_bp = lp1->l_bp;
  272.     lp1->l_bp = lp2;
  273.     lp2->l_bp->l_fp = lp2;
  274.     lp2->l_fp = lp1;
  275.     wp = wheadp;                /* Windows        */
  276.     while (wp != NULL) {
  277.         if (wp->w_linep == lp1)
  278.             wp->w_linep = lp2;
  279.         if (wp->w_dotp == lp1) {
  280.             if (wp->w_doto < doto)
  281.                 wp->w_dotp = lp2;
  282.             else
  283.                 wp->w_doto -= doto;
  284.         }
  285.         if (wp->w_markp == lp1) {
  286.             if (wp->w_marko < doto)
  287.                 wp->w_markp = lp2;
  288.             else
  289.                 wp->w_marko -= doto;
  290.         }
  291.         wp = wp->w_wndp;
  292.     }    
  293.     return (TRUE);
  294. }
  295.  
  296. /*
  297.  * This function deletes "n" bytes,
  298.  * starting at dot. It understands how do deal
  299.  * with end of lines, etc. It returns TRUE if all
  300.  * of the characters were deleted, and FALSE if
  301.  * they were not (because dot ran into the end of
  302.  * the buffer. The "kflag" indicates either no insertion,
  303.  * or direction of insertion into the kill buffer.
  304.  */
  305. ldelete(n, kflag) RSIZE n; {
  306.     register char    *cp1;
  307.     register char    *cp2;
  308.     register LINE    *dotp;
  309.     register int    doto;
  310.     register RSIZE    chunk;
  311.     register WINDOW    *wp;
  312.  
  313.     /*
  314.      * HACK - doesn't matter, and fixes back-over-nl bug for empty
  315.      *    kill buffers.
  316.      */
  317.     if (kused == kstart) kflag = KFORW;
  318.  
  319.     while (n != 0) {
  320.         dotp = curwp->w_dotp;
  321.         doto = curwp->w_doto;
  322.         if (dotp == curbp->b_linep)    /* Hit end of buffer.    */
  323.             return (FALSE);
  324.         chunk = dotp->l_used-doto;    /* Size of chunk.    */
  325.         if (chunk > n)
  326.             chunk = n;
  327.         if (chunk == 0) {        /* End of line, merge.    */
  328.             lchange(WFHARD);
  329.             if (ldelnewline() == FALSE
  330.             || (kflag!=KNONE && kinsert('\n', kflag)==FALSE))
  331.                 return (FALSE);
  332.             --n;
  333.             continue;
  334.         }
  335.         lchange(WFEDIT);
  336.         cp1 = &dotp->l_text[doto];    /* Scrunch text.    */
  337.         cp2 = cp1 + chunk;
  338.         if (kflag == KFORW) {
  339.             while (ksize - kused < chunk)
  340.                 if (kgrow(FALSE) == FALSE) return FALSE;
  341.             bcopy(cp1, &(kbufp[kused]), (int) chunk);
  342.             kused += chunk;
  343.         } else if (kflag == KBACK) {
  344.             while (kstart < chunk)
  345.                 if (kgrow(TRUE) == FALSE) return FALSE;
  346.             bcopy(cp1, &(kbufp[kstart-chunk]), (int) chunk);
  347.             kstart -= chunk;
  348.         } else if (kflag != KNONE) panic("broken ldelete call");
  349.         while (cp2 != &dotp->l_text[dotp->l_used])
  350.             *cp1++ = *cp2++;
  351.         dotp->l_used -= (int) chunk;
  352.         wp = wheadp;            /* Fix windows        */
  353.         while (wp != NULL) {
  354.             if (wp->w_dotp==dotp && wp->w_doto>=doto) {
  355.                 /*NOSTRICT*/
  356.                 wp->w_doto -= chunk;
  357.                 if (wp->w_doto < doto)
  358.                     wp->w_doto = doto;
  359.             }    
  360.             if (wp->w_markp==dotp && wp->w_marko>=doto) {
  361.                 /*NOSTRICT*/
  362.                 wp->w_marko -= chunk;
  363.                 if (wp->w_marko < doto)
  364.                     wp->w_marko = doto;
  365.             }
  366.             wp = wp->w_wndp;
  367.         }
  368.         n -= chunk;
  369.     }
  370.     return (TRUE);
  371. }
  372.  
  373. /*
  374.  * Delete a newline. Join the current line
  375.  * with the next line. If the next line is the magic
  376.  * header line always return TRUE; merging the last line
  377.  * with the header line can be thought of as always being a
  378.  * successful operation, even if nothing is done, and this makes
  379.  * the kill buffer work "right". Easy cases can be done by
  380.  * shuffling data around. Hard cases require that lines be moved
  381.  * about in memory. Return FALSE on error and TRUE if all
  382.  * looks ok.
  383.  */
  384. ldelnewline() {
  385.     register char    *cp1;
  386.     register char    *cp2;
  387.     register LINE    *lp1;
  388.     register LINE    *lp2;
  389.     register LINE    *lp3;
  390.     register WINDOW    *wp;
  391.  
  392.     lp1 = curwp->w_dotp;
  393.     lp2 = lp1->l_fp;
  394.     if (lp2 == curbp->b_linep) {        /* At the buffer end.    */
  395.         if (lp1->l_used == 0)        /* Blank line.        */
  396.             lfree(lp1);
  397.         return (TRUE);
  398.     }
  399.     if (lp2->l_used <= lp1->l_size-lp1->l_used) {
  400.         cp1 = &lp1->l_text[lp1->l_used];
  401.         cp2 = &lp2->l_text[0];
  402.         while (cp2 != &lp2->l_text[lp2->l_used])
  403.             *cp1++ = *cp2++;
  404.         wp = wheadp;
  405.         while (wp != NULL) {
  406.             if (wp->w_linep == lp2)
  407.                 wp->w_linep = lp1;
  408.             if (wp->w_dotp == lp2) {
  409.                 wp->w_dotp  = lp1;
  410.                 wp->w_doto += lp1->l_used;
  411.             }
  412.             if (wp->w_markp == lp2) {
  413.                 wp->w_markp  = lp1;
  414.                 wp->w_marko += lp1->l_used;
  415.             }
  416.             wp = wp->w_wndp;
  417.         }        
  418.         lp1->l_used += lp2->l_used;
  419.         lp1->l_fp = lp2->l_fp;
  420.         lp2->l_fp->l_bp = lp1;
  421.         free((char *) lp2);
  422.         return (TRUE);
  423.     }
  424.     if ((lp3=lalloc((RSIZE) (lp1->l_used+lp2->l_used))) == NULL)
  425.         return (FALSE);
  426.     cp1 = &lp1->l_text[0];
  427.     cp2 = &lp3->l_text[0];
  428.     while (cp1 != &lp1->l_text[lp1->l_used])
  429.         *cp2++ = *cp1++;
  430.     cp1 = &lp2->l_text[0];
  431.     while (cp1 != &lp2->l_text[lp2->l_used])
  432.         *cp2++ = *cp1++;
  433.     lp1->l_bp->l_fp = lp3;
  434.     lp3->l_fp = lp2->l_fp;
  435.     lp2->l_fp->l_bp = lp3;
  436.     lp3->l_bp = lp1->l_bp;
  437.     wp = wheadp;
  438.     while (wp != NULL) {
  439.         if (wp->w_linep==lp1 || wp->w_linep==lp2)
  440.             wp->w_linep = lp3;
  441.         if (wp->w_dotp == lp1)
  442.             wp->w_dotp  = lp3;
  443.         else if (wp->w_dotp == lp2) {
  444.             wp->w_dotp  = lp3;
  445.             wp->w_doto += lp1->l_used;
  446.         }
  447.         if (wp->w_markp == lp1)
  448.             wp->w_markp  = lp3;
  449.         else if (wp->w_markp == lp2) {
  450.             wp->w_markp  = lp3;
  451.             wp->w_marko += lp1->l_used;
  452.         }
  453.         wp = wp->w_wndp;
  454.     }
  455.     free((char *) lp1);
  456.     free((char *) lp2);
  457.     return (TRUE);
  458. }
  459.  
  460. /*
  461.  * Replace plen characters before dot with argument string.
  462.  * Control-J characters in st are interpreted as newlines.
  463.  * There is a casehack disable flag (normally it likes to match
  464.  * case of replacement to what was there).
  465.  */
  466. lreplace(plen, st, f)
  467. register RSIZE    plen;            /* length to remove        */
  468. char        *st;            /* replacement string        */
  469. int        f;            /* case hack disable        */
  470. {
  471.     register RSIZE    rlen;        /* replacement length        */
  472.     register int    rtype;        /* capitalization         */
  473.     register int    c;        /* used for random characters    */
  474.     register int    doto;        /* offset into line        */
  475.  
  476.     /*
  477.      * Find the capitalization of the word that was found.
  478.      * f says use exact case of replacement string (same thing that
  479.      * happens with lowercase found), so bypass check.
  480.      */
  481.     /*NOSTRICT*/
  482.     (VOID) backchar(TRUE, (int) plen, KRANDOM);
  483.     rtype = _L;
  484.     c = lgetc(curwp->w_dotp, curwp->w_doto);
  485.     if (ISUPPER(c)!=FALSE  &&  f==FALSE) {
  486.         rtype = _U|_L;
  487.         if (curwp->w_doto+1 < llength(curwp->w_dotp)) {
  488.             c = lgetc(curwp->w_dotp, curwp->w_doto+1);
  489.             if (ISUPPER(c) != FALSE) {
  490.                 rtype = _U;
  491.             }
  492.         }
  493.     }
  494.  
  495.     /*
  496.      * make the string lengths match (either pad the line
  497.      * so that it will fit, or scrunch out the excess).
  498.      * be careful with dot's offset.
  499.      */
  500.     rlen = strlen(st);
  501.     doto = curwp->w_doto;
  502.     if (plen > rlen)
  503.         (VOID) ldelete((RSIZE) (plen-rlen), KNONE);
  504.     else if (plen < rlen) {
  505.         if (linsert((RSIZE) (rlen-plen), ' ') == FALSE)
  506.             return (FALSE);
  507.     }
  508.     curwp->w_doto = doto;
  509.  
  510.     /*
  511.      * do the replacement:  If was capital, then place first 
  512.      * char as if upper, and subsequent chars as if lower.  
  513.      * If inserting upper, check replacement for case.
  514.      */
  515.     while ((c = *st++&0xff) != '\0') {
  516.         if ((rtype&_U)!=0  &&  ISLOWER(c)!=0)
  517.             c = TOUPPER(c);
  518.         if (rtype == (_U|_L))
  519.             rtype = _L;
  520.         if (c == SEOL) {
  521.             if (curwp->w_doto == llength(curwp->w_dotp))
  522.                 (VOID) forwchar(FALSE, 1, KRANDOM);
  523.             else {
  524.                 if (ldelete((RSIZE) 1, KNONE) != FALSE)
  525.                     (VOID) lnewline();
  526.             }
  527.         } else if (curwp->w_dotp == curbp->b_linep) {
  528.             (VOID) linsert((RSIZE) 1, c);
  529.         } else if (curwp->w_doto == llength(curwp->w_dotp)) {
  530.             if (ldelete((RSIZE) 1, KNONE) != FALSE)
  531.                 (VOID) linsert((RSIZE) 1, c);
  532.         } else
  533.             lputc(curwp->w_dotp, curwp->w_doto++, c);
  534.     }
  535.     lchange(WFHARD);
  536.     return (TRUE);
  537. }
  538.  
  539. /*
  540.  * Delete all of the text
  541.  * saved in the kill buffer. Called by commands
  542.  * when a new kill context is being created. The kill
  543.  * buffer array is released, just in case the buffer has
  544.  * grown to immense size. No errors.
  545.  */
  546. kdelete() {
  547.     if (kbufp != NULL) {
  548.         free((char *) kbufp);
  549.         kbufp = NULL;
  550.         kstart = kused = ksize = 0;
  551.     }
  552. }
  553.  
  554. /*
  555.  * Insert a character to the kill buffer,
  556.  * enlarging the buffer if there isn't any room. Always
  557.  * grow the buffer in chunks, on the assumption that if you
  558.  * put something in the kill buffer you are going to put
  559.  * more stuff there too later. Return TRUE if all is
  560.  * well, and FALSE on errors. Print a message on
  561.  * errors. Dir says whether to put it at back or front.
  562.  */
  563. kinsert(c, dir) {
  564.  
  565.     if (kused == ksize && dir == KFORW && kgrow(FALSE) == FALSE)
  566.         return FALSE;
  567.     if (kstart == 0 && dir == KBACK && kgrow(TRUE) == FALSE)
  568.         return FALSE;
  569.     if (dir == KFORW) kbufp[kused++] = c;
  570.     else if (dir == KBACK) kbufp[--kstart] = c;
  571.     else panic("broken kinsert call");        /* Oh shit! */
  572.     return (TRUE);
  573. }
  574.  
  575. /*
  576.  * kgrow - just get more kill buffer for the callee. back is true if
  577.  * we are trying to get space at the beginning of the kill buffer.
  578.  */
  579. kgrow(back) {
  580.     register int    nstart;
  581.     register char    *nbufp;
  582.  
  583.     if ((nbufp=malloc((int)(ksize+KBLOCK))) == NULL) {
  584.         ewprintf("Can't get %ld bytes", (long)(ksize+KBLOCK));
  585.         return (FALSE);
  586.     }
  587.     nstart = (back == TRUE) ? (kstart + KBLOCK) : (KBLOCK / 4) ;
  588.     bcopy(&(kbufp[kstart]), &(nbufp[nstart]), (int) (kused-kstart));
  589.     if (kbufp != NULL)
  590.         free((char *) kbufp);
  591.     kbufp  = nbufp;
  592.     ksize += KBLOCK;
  593.     kused = kused - kstart + nstart;
  594.     kstart = nstart;
  595.     return TRUE;
  596. }
  597.  
  598. /*
  599.  * This function gets characters from
  600.  * the kill buffer. If the character index "n" is
  601.  * off the end, it returns "-1". This lets the caller
  602.  * just scan along until it gets a "-1" back.
  603.  */
  604. kremove(n) {
  605.     if (n < 0 || n + kstart >= kused)
  606.         return (-1);
  607.     return (kbufp[n + kstart] & 0xFF);
  608. }
  609.